package br.com.duosoftware.orcamento.managedbeans;

import br.com.duosoftware.orcamento.daos.FuncaoDAO;
import br.com.duosoftware.orcamento.daos.HorizonteTemporalDAO;
import br.com.duosoftware.orcamento.daos.IndicadorDAO;
import br.com.duosoftware.orcamento.daos.NaturezaDoProgramaDAO;
import br.com.duosoftware.orcamento.daos.ProgramaDAO;
import br.com.duosoftware.orcamento.daos.TipoDePrazoDAO;
import br.com.duosoftware.orcamento.daos.UnidadeOrcamentariaDAO;
import br.com.duosoftware.orcamento.entidades.Funcao;
import br.com.duosoftware.orcamento.entidades.HorizonteTemporal;
import br.com.duosoftware.orcamento.entidades.Indicador;
import br.com.duosoftware.orcamento.entidades.NaturezaDoPrograma;
import br.com.duosoftware.orcamento.entidades.Programa;
import br.com.duosoftware.orcamento.entidades.TipoDePrazo;
import br.com.duosoftware.orcamento.entidades.UnidadeOrcamentaria;
import br.com.duosoftware.orcamento.utils.Mensagens;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.model.SelectItem;
import org.hibernate.exception.ConstraintViolationException;
import org.primefaces.context.RequestContext;

/**
 *
 * @author Daniel
 * 
 */

@ManagedBean
@ViewScoped
public class ProgramaBean implements Serializable {

    private Programa programa;
    private List<Programa> programas;
    private ProgramaDAO programaDAO;
    
    //************SelectItens*******************
    private List<SelectItem> horizontesTemporais;
    private List<SelectItem> tiposDePrazo;
    private List<SelectItem> naturezasDeProgramas;
    private List<SelectItem> unidadesOrcamentarias;
    private List<SelectItem> indicadores;
    private List<SelectItem> funcoes;
    
    
    public ProgramaBean() {
        programaDAO = new ProgramaDAO();
    }

    public Programa getPrograma() {
        return programa;
    }

    public void setPrograma(Programa programa) {
        this.programa = programa;
    }

    public List<Programa> getProgramas() {
        if(programas == null){
            programas = programaDAO.listarProgramas();
        }
        return programas;
    }

    public void setProgramas(List<Programa> programas) {
        this.programas = programas;
    }
    
    /**
     * <b>Método que inicializa a programa a ser cadastrado.</b><p>
     *
     * @return void
     *
     */
    public void adicionarInicio() {

        programa = new Programa();
        
    }

    /**
     * <b>Método que adiciona ou edita uma Programa</b><p>
     *
     * Após o término o método fecha o dialog de cadastro. <p>
     * 
     * @return void
     *
     */
    public void adicionarEditarFim() {

        programaDAO.salvarOuAtualizar(programa);
        programa = new Programa();
        programas = null;
        
        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPrograma.hide()");
        requestContext.update("formProgramas:dtProgramas");

    }

    /**
     * <b>Método para iniciar o processo de edição de um Programa.</b> <p>
     *
     * Ele verifica se há um Programa selecionada para edição, se não houver é
     * emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um Programa selecionado o médoto abre o dialog para
     * edição<p>
     *
     * @return void
     *
     */
    public void editarInicio() {

        if (programa == null) {

            Mensagens.mensagemDeAlerta("Selecione um registro", "Selecione um re"
                    + "gistro para Editar");

        }else{
        
            RequestContext.getCurrentInstance().execute("dlgPrograma.show()");
            
        }

    }

    /**
     * <b>Método para iniciar o processo de exclusão de um Programa.</b> <p>
     *
     * Ele verifica se há uma Programa selecionado para exclusão, se não houver é
     * emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um Programa selecionado o médoto abre um p:dialog para confirma
     * ção da exclusão.<p>
     *
     * @return void
     *
     */
    public void excluirInicio() {

        if (programa == null) {
            Mensagens.mensagemDeAlerta("Selecione um registro",
                    "Selecione um registro para excluir");
        } else {
            RequestContext.getCurrentInstance()
                    .execute("dlgExcluirPrograma.show()");
        }

    }

    /**
     * <b>Método para excluir um Programa.</b> <p>
     *
     * Ele verifica se a Programa selecionado para exclusão está sendo 
     * utilizado por alguma outra tabela do banco. Se estiver uma mensagem de 
     * aviso é dada ao usuário<p>
     *
     * @return void
     *
     */
    public void excluirFim() {

        try {

            programaDAO.excluir(programa);
            programa = new Programa();
            programas = null;
            
        } catch (ConstraintViolationException e) {
            Mensagens.mensagemDeAlerta("Registro Utilizado",
                    "Esse registro está sendo utilizado");
        }
        
        RequestContext.getCurrentInstance()
                    .execute("dlgExcluirPrograma.hide()");

    }

    /**
     * <b> Método para cancelar uma operação de cadastro ou edição.</b> <p>
     *
     * O método instancia um novo objeto na variável Programa para limpar as
     * infomações.<p>
     *
     * @return void
     */
    public void cancelar() {

        programa = new Programa();

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPrograma.hide()");
        requestContext.update("formPrograma:dtProgramas");

    }
    
    //************************get's de SelectItens******************************
    
    public List<SelectItem> getHorizontesTemporais() {
        if (horizontesTemporais == null) {

            horizontesTemporais = new LinkedList<SelectItem>();

            List<HorizonteTemporal> horizontes = new HorizonteTemporalDAO()
                    .listarHorizontesTemporais();

            if (horizontes != null) {

                for (HorizonteTemporal ht : horizontes) {

                    horizontesTemporais.add(new SelectItem(ht, ht.toString()));

                }

            }
        }
        return horizontesTemporais;
    }

    public List<SelectItem> getTiposDePrazo() {

        if (tiposDePrazo == null) {

            tiposDePrazo = new LinkedList<SelectItem>();

            List<TipoDePrazo> tipos = new TipoDePrazoDAO()
                    .listarTiposPrazo();

            if (tipos != null) {

                for (TipoDePrazo t : tipos) {

                    tiposDePrazo.add(new SelectItem(t, t.toString()));
                }
            }

        }

        return tiposDePrazo;

    }

    public List<SelectItem> getUnidadesOrcamentarias() {

        unidadesOrcamentarias = new LinkedList<SelectItem>();

        List<UnidadeOrcamentaria> unidades = new UnidadeOrcamentariaDAO()
                .listarUnidadesOrcamentarias();

        if (unidades != null) {

            for (UnidadeOrcamentaria uo : unidades) {
                unidadesOrcamentarias.add(new SelectItem(uo, uo.toString()));
            }

        }


        return unidadesOrcamentarias;
    }

    public List<SelectItem> getNaturezas() {

        if (naturezasDeProgramas == null) {

            naturezasDeProgramas = new LinkedList<SelectItem>();

            List<NaturezaDoPrograma> naturezas = new NaturezaDoProgramaDAO()
                    .listarNaturezasDoPrograma();

            if (naturezas != null) {

                for (NaturezaDoPrograma n : naturezas) {
                    naturezasDeProgramas.add(new SelectItem(n, n.toString()));
                }

            }

        }

        return naturezasDeProgramas;
    }

    public List<SelectItem> getIndicadores() {

        indicadores = new LinkedList<SelectItem>();

        List<Indicador> inds = new IndicadorDAO().listarIndicadores();

        if (inds != null) {

            for (Indicador i : inds) {
                indicadores.add(new SelectItem(i, i.toString()));
            }

        }

        return indicadores;
    }

    public List<SelectItem> getFuncoes() {

        if (funcoes == null) {

            funcoes = new LinkedList<SelectItem>();

            List<Funcao> funcs = new FuncaoDAO().listarFuncoes();

            if (funcs != null) {

                for (Funcao f : funcs) {
                    funcoes.add(new SelectItem(f, f.toString()));
                }

            }

        }

        return funcoes;
    }
    
}
